package com.itCar.base.tools;

import cn.hutool.core.text.StrFormatter;
import com.alibaba.fastjson.JSONArray;
import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
import org.apache.commons.lang.math.RandomUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import java.io.*;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

/**
 * @ClassName: StringUtils
 * @Author: hhxx_liuzhiguo
 * @CreateTime: 2023-09-01  09:43
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils {

    /**
     * 空字符串
     */
    private static final String NULLSTR = "";

    /**
     * 下划线
     */
    private static final char SEPARATOR = '_';


    private static final Character kongge = 32; // 空格
    private static final Character huiche = 13; // 回车
    private static final Character huanhang = 10; // 换行
    /*字符串*/
    private static final String keyString = "s-vL3:caT%ws?oNn.^d}i7)?k3ngeAy6,vw,s-yCJ6nq05BKjF8Rg=D3,:2of}q8jh@0+0TTAa16Z@@:>L#^j6E12_Pn5+i^Uu0~o!G7na.U*H_:Ak179]4:ee2V+K00}maaeo#T>gwCuY?gk0ysRNXq?zPuXB1oZX1MQJNWdv%%Qb-:kqAxUL7+ACd-Q6p.cQXUN=Zw!Yo,.Rc9U3#*zrr:.B0?]h}vv?C_3@Xu5>W#@7shrGX15p.@wq4yeR2zC=Tz!%FR#iKU.Pi_5N*QXN,]!NqdzkL0f5.%RDvnR7V7):sdfNCo0W69h:KLp2@G-hW:M=-dnLx+kFyPW-*k>eN3~ke!~]iC]}:o}uRUnuDj?54VA#kA!vZ@vLq=gd,R@QeKQA0Yqb8R2>tA7FgepDyu!jcZk~_9cj~+i?bbE_DvQjVCAWQdRkpjh]^EDs_0T+ofVystE}qrwPM:3EdBv*.mG5t1LBkDV8G]0iKX}]Q}T^uoi+5%H%F%mKtDVnZHB@,Y%M0:6:vNF5o#01gUizWe23:1ZjDgcN?M*+1dEbYhhL-im]^z*D*^G+BFi!88KJ,>inMXqk}PNPJ?)2JAmC%v";

    /**
     * 获取参数不为空值
     *
     * @param value defaultValue 要判断的value
     * @return value 返回值
     */
    public static <T> T nvl(T value, T defaultValue) {
        return value != null ? value : defaultValue;
    }

    /**
     * * 判断一个Collection是否为空， 包含List，Set，Queue
     *
     * @param coll 要判断的Collection
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Collection<?> coll) {
        return isNull(coll) || coll.isEmpty();
    }

    /**
     * * 判断一个Collection是否非空，包含List，Set，Queue
     *
     * @param coll 要判断的Collection
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Collection<?> coll) {
        return !isEmpty(coll);
    }

    /**
     * * 判断一个对象数组是否为空
     *
     * @param objects 要判断的对象数组
     *                * @return true：为空 false：非空
     */
    public static boolean isEmpty(Object[] objects) {
        return isNull(objects) || (objects.length == 0);
    }

    /**
     * * 判断一个对象数组是否非空
     *
     * @param objects 要判断的对象数组
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Object[] objects) {
        return !isEmpty(objects);
    }

    /**
     * * 判断一个Map是否为空
     *
     * @param map 要判断的Map
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Map<?, ?> map) {
        return isNull(map) || map.isEmpty();
    }

    /**
     * * 判断一个Map是否为空
     *
     * @param map 要判断的Map
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Map<?, ?> map) {
        return !isEmpty(map);
    }

    /**
     * * 判断一个字符串是否为空串
     *
     * @param str String
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(String str) {
        return isNull(str) || NULLSTR.equals(str.trim());
    }

    /**
     * * 判断一个字符串是否为非空串
     *
     * @param str String
     * @return true：非空串 false：空串
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    /**
     * * 判断一个对象是否为空
     *
     * @param object Object
     * @return true：为空 false：非空
     */
    public static boolean isNull(Object object) {
        return object == null;
    }

    /**
     * * 判断一个对象是否非空
     *
     * @param object Object
     * @return true：非空 false：空
     */
    public static boolean isNotNull(Object object) {
        return !isNull(object);
    }

    /**
     * * 判断一个字符串是否为空串,为空给默认值0
     *
     * @param str String
     * @return true：为空 false：非空
     */
    public static Object isDefaultValue(Object str) {
        if (isNull(str) || NULLSTR.equals(str)) {
            return "0";
        } else {
            return str;
        }
    }

    /**
     * * 判断一个对象是否是数组类型（Java基本型别的数组）
     *
     * @param object 对象
     * @return true：是数组 false：不是数组
     */
    public static boolean isArray(Object object) {
        return isNotNull(object) && object.getClass().isArray();
    }

    /**
     * 去空格
     */
    public static String trim(String str) {
        return (str == null ? "" : str.trim());
    }

    /**
     * 截取字符串
     *
     * @param str   字符串
     * @param start 开始
     * @return 结果
     */
    public static String substring(final String str, int start) {
        if (str == null) {
            return NULLSTR;
        }

        if (start < 0) {
            start = str.length() + start;
        }

        if (start < 0) {
            start = 0;
        }
        if (start > str.length()) {
            return NULLSTR;
        }

        return str.substring(start);
    }

    /**
     * 截取字符串
     *
     * @param str   字符串
     * @param start 开始
     * @param end   结束
     * @return 结果
     */
    public static String substring(final String str, int start, int end) {
        if (str == null) {
            return NULLSTR;
        }

        if (end < 0) {
            end = str.length() + end;
        }
        if (start < 0) {
            start = str.length() + start;
        }

        if (end > str.length()) {
            end = str.length();
        }

        if (start > end) {
            return NULLSTR;
        }

        if (start < 0) {
            start = 0;
        }
        if (end < 0) {
            end = 0;
        }

        return str.substring(start, end);
    }

    /**
     * 格式化文本, {} 表示占位符<br>
     * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
     * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
     * 例：<br>
     * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
     * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
     * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
     *
     * @param template 文本模板，被替换的部分用 {} 表示
     * @param params   参数值
     * @return 格式化后的文本
     */
    public static String format(String template, Object... params) {
        if (isEmpty(params) || isEmpty(template)) {
            return template;
        }
        return StrFormatter.format(template, params);
    }

    /**
     * 驼峰转下划线命名
     */
    public static String toUnderScoreCase(String str) {
        if (str == null) {
            return null;
        }
        StringBuilder sb = new StringBuilder();
        // 前置字符是否大写
        boolean preCharIsUpperCase = true;
        // 当前字符是否大写
        boolean curreCharIsUpperCase = true;
        // 下一字符是否大写
        boolean nexteCharIsUpperCase = true;
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (i > 0) {
                preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
            } else {
                preCharIsUpperCase = false;
            }

            curreCharIsUpperCase = Character.isUpperCase(c);

            if (i < (str.length() - 1)) {
                nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
            }

            if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase) {
                sb.append(SEPARATOR);
            } else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase) {
                sb.append(SEPARATOR);
            }
            sb.append(Character.toLowerCase(c));
        }
        return sb.toString();
    }

    /**
     * 是否包含字符串
     *
     * @param str  验证字符串
     * @param strs 字符串组
     * @return 包含返回true
     */
    public static boolean inStringIgnoreCase(String str, String... strs) {
        if (str != null && strs != null) {
            for (String s : strs) {
                if (str.equalsIgnoreCase(trim(s))) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
     *
     * @param name 转换前的下划线大写方式命名的字符串
     * @return 转换后的驼峰式命名的字符串
     */
    public static String convertToCamelCase(String name) {
        StringBuilder result = new StringBuilder();
        // 快速检查
        if (name == null || name.isEmpty()) {
            // 没必要转换
            return "";
        } else if (!name.contains("_")) {
            // 不含下划线，仅将首字母大写
            return name.substring(0, 1).toUpperCase() + name.substring(1);
        }
        // 用下划线将原始字符串分割
        String[] camels = name.split("_");
        for (String camel : camels) {
            // 跳过原始字符串中开头、结尾的下换线或双重下划线
            if (camel.isEmpty()) {
                continue;
            }
            // 首字母大写
            result.append(camel.substring(0, 1).toUpperCase());
            result.append(camel.substring(1).toLowerCase());
        }
        return result.toString();
    }

    /**
     * 驼峰式命名法
     * 例如：user_name->userName
     */
    public static String toCamelCase(String s) {
        if (s == null) {
            return null;
        }
        if (s.indexOf(SEPARATOR) == -1) {
            return s;
        }
        s = s.toLowerCase();
        StringBuilder sb = new StringBuilder(s.length());
        boolean upperCase = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (c == SEPARATOR) {
                upperCase = true;
            } else if (upperCase) {
                sb.append(Character.toUpperCase(c));
                upperCase = false;
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    @SuppressWarnings("unchecked")
    public static <T> T cast(Object obj) {
        return (T) obj;
    }

    public static byte[] serialize(Object obj) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            GZIPOutputStream gzout = new GZIPOutputStream(baos);
            ObjectOutputStream oos = new ObjectOutputStream(gzout);
            oos.writeObject(obj);
            oos.flush();
            oos.close();
            gzout.close();
            byte[] bs = baos.toByteArray();
            baos.close();
            return bs;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static Object deserialize(byte[] bits) {
        try {
            ByteArrayInputStream bais = new ByteArrayInputStream(bits);
            GZIPInputStream gzin = new GZIPInputStream(bais);
            ObjectInputStream ois = new ObjectInputStream(gzin);
            Object obj = ois.readObject();
            ois.close();
            gzin.close();
            bais.close();
            return obj;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 替换字符串中特殊字符
     */
    public static String formatString2XML(String strData) {
        if (strData == null) {
            return "";
        }
        strData = replaceString(strData, "&", "&amp;");
        strData = replaceString(strData, "<", "&lt;");
        strData = replaceString(strData, ">", "&gt;");
        strData = replaceString(strData, "&apos;", "&apos;");
        strData = replaceString(strData, "\"", "&quot;");
        return strData;
    }

    /**
     * 还原字符串中特殊字符
     */
    public static String formatStringXML2String(String strData) {
        strData = replaceString(strData, "&lt;", "<");
        strData = replaceString(strData, "&gt;", ">");
        strData = replaceString(strData, "&apos;", "&apos;");
        strData = replaceString(strData, "&quot;", "\"");
        strData = replaceString(strData, "&amp;", "&");
        return strData;
    }

    /**
     * 处理JSON中的特殊字符
     */
    public static String convertToJsonString(String str) {
        if (str == null) {
            return "";
        } else {
            return str.replace("\\", "\\\\").replace("\"", "\\\"")
                    /*.replace("'", "\\\'")*/.replace("\r", "\\r")
                    .replace("\n", "\\n").replace("\t", "\\t")
                    .replace("\b", "\\b").replace("  ", "").trim();
            //.replace("\b", "\\b").replace("/", " ").replace("  ", "").trim();
        }
    }

    /**
     * 处理JSON中的特殊字符
     */
    public static String convertToSqlString(String str) {
        return str.replace("'", "''");
    }

    /**
     * 替换一个字符串中的某些指定字符
     *
     * @param strData     String 原始字符串
     * @param regex       String 要替换的字符串
     * @param replacement String 替代字符串
     * @return String 替换后的字符串
     */
    public static String replaceString(String strData, String regex, String replacement) {
        if (strData == null) {
            return null;
        }
        int index;
        index = strData.indexOf(regex);
        String strNew = "";
        if (index >= 0) {
            while (index >= 0) {
                strNew += strData.substring(0, index) + replacement;
                strData = strData.substring(index + regex.length());
                index = strData.indexOf(regex);
            }
            strNew += strData;
            return strNew;
        }
        return strData;
    }

    /**
     * 字符串转html格式
     *
     * @param str
     * @return
     */
    public static String jsstr2html(String str) {
        return content2html(jsstr2content(str));
    }

    /**
     * 去掉\
     *
     * @param str
     * @return
     */
    public static String jsstr2content(String str) {
        return str == null ? "" : str.replace("\\r", huiche.toString()).replace("\\n", huanhang.toString())
                .replace("\\\"", "\"").replace("\\'", "'");
    }

    /**
     * 将特殊符号转为html格式
     *
     * @param content
     * @return
     */
    public static String content2html(String content) {
        return content.replace("&", "&amp;").replace(kongge.toString(), "&nbsp;").replace("<", "&lt;")
                .replace(">", "&gt;").replace("\"", "&quot;").replace(huiche.toString() + huanhang.toString(), "<br/>")
                .replace(huiche.toString(), "<br/>").replace(huanhang.toString(), "<br/>");
    }

    public static String replaceBlank(String str) {
        String dest = "";
        if (str != null) {
            Pattern p = Pattern.compile("\\s*|\t|\r|\n");
            Matcher m = p.matcher(str);
            dest = m.replaceAll("");
        }
        return dest;
    }

    public static String[] splitAndRemoveEmpty(String source, String pattern) {
        ArrayList<String> result = new ArrayList<String>();
        String[] vals = source.split(pattern);
        for (String val : vals) {
            if (StringUtils.isNotBlank(val)) {
                result.add(val.trim());
            }
        }
        return result.toArray(new String[0]);
    }

    /**
     * byte数组转换成16进制字符串
     *
     * @param src
     * @return
     */
    public static String bytesToHexString(byte[] src) {
        StringBuilder stringBuilder = new StringBuilder();
        if (src == null || src.length <= 0) {
            return null;
        }
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
        }
        return stringBuilder.toString();
    }

    /**
     * hex字符串转byte数组
     *
     * @param inHex 待转换的Hex字符串
     * @return 转换后的byte数组结果
     */
    public static byte[] hexToByteArray(String inHex) {
        if (StringUtils.isEmpty(inHex)) {
            return null;
        }
        int hexlen = inHex.length();
        byte[] result;
        if (hexlen % 2 == 1) {
            // 奇数
            hexlen++;
            result = new byte[(hexlen / 2)];
            inHex = "0" + inHex;
        } else {
            // 偶数
            result = new byte[(hexlen / 2)];
        }
        int j = 0;
        for (int i = 0; i < hexlen; i += 2) {
            result[j] = (byte) Integer.parseInt(inHex.substring(i, i + 2), 16);
            j++;
        }
        return result;
    }

    /**
     * 随机字符串
     *
     * @param len 字符长度
     * @return 随机字符串
     */

    public static String getRandomKey(int len) {
        if (len < 1 || len > keyString.length() - 30) {
            len = keyString.length() - 30;
        }
        int pos = RandomUtils.nextInt(keyString.length() - len - 1);
        return keyString.substring(pos, pos + len);
    }

    public static List<Map<String, Object>> address() {
        Resource resource = new ClassPathResource("static/vuecommon/address.js");
        List<Map<String, Object>> listObjectSec = null;
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(resource.getInputStream(), "UTF-8"));
            String message = org.apache.commons.io.IOUtils.toString(br);
            message = message.substring(message.indexOf("=") + 1, message.length());

            listObjectSec = JSONArray.parseObject(message, List.class);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            //e.printStackTrace();
        }
        return listObjectSec;
    }

    /**
     * double小数点格式化
     *
     * @param value
     * @return
     */
    public static String valueFormat(String value) {
        DecimalFormat df = new DecimalFormat("#####.##");
        String xs = StringUtils.isEmpty(value) ? "" : df.format(new BigDecimal(value));
        return xs;
    }

    public static String valueFormat3(String value) {
        DecimalFormat df = new DecimalFormat("#####.###");
        String xs = StringUtils.isEmpty(value) ? "" : df.format(new BigDecimal(value));
        return xs;
    }

    public static String valueFormatCommon(String value) {
        String xs = "";
        if (StringUtils.isEmpty(value)) {
            return xs;
        }
        int lastIndexOf = value.lastIndexOf(".");
        int count = value.length() - 1 - lastIndexOf;
        StringBuilder info = new StringBuilder();
        for (int i = 0; i < count; i++) {
            info.append("#");
        }
        DecimalFormat df = new DecimalFormat("#####." + info.toString() + "");
        xs = df.format(new BigDecimal(value));
        return xs;
    }

    /**
     * 根据传入中文汉字转换为拼音首 例如：弘康->hk
     *
     * @param chinese
     * @return
     */
    public static String ToFirstChar(String chinese) {
        String pinyinStr = "";
        char[] newChar = chinese.toCharArray(); //转为单个字符
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
        for (int i = 0; i < newChar.length; i++) {
            if (newChar[i] > 128) {
                try {
                    pinyinStr += PinyinHelper.toHanyuPinyinStringArray(newChar[i], defaultFormat)[0].charAt(0);
                } catch (BadHanyuPinyinOutputFormatCombination e) {
                    e.printStackTrace();
                }
            } else {
                pinyinStr += newChar[i];
            }
        }
        return pinyinStr;
    }

    /**
     * 下划线转驼峰新
     *
     * @param name
     * @return
     */
    public static String convertToCamelCase_new(String name) {
        StringBuilder result = new StringBuilder();
        // 快速检查
        if (name == null || name.isEmpty()) {
            // 没必要转换
            return "";
        } else if (!name.contains("_")) {
            // 不含下划线，仅将首字母大写
            return name.toLowerCase();
        }
        // 用下划线将原始字符串分割
        String[] camels = name.split("_");
        for (String camel : camels) {
            // 跳过原始字符串中开头、结尾的下换线或双重下划线
            if (camel.isEmpty()) {
                continue;
            }
            // 首字母大写
            result.append(camel.substring(0, 1).toUpperCase());
            result.append(camel.substring(1).toLowerCase());
        }
        StringBuilder ret = new StringBuilder(result.substring(0, 1).toLowerCase());
        ret.append(result.substring(1, result.toString().length()));
        return ret.toString();
    }
}
